A virtual machine, such as a Java virtual machine (JVM), may load, compile, and execute or interpret programmed behaviors of defined types, such as classes. The structure and behavior of a type may be defined in a representation, such as a class file, that has descriptive metadata and bytecode instructions.
In a nominally-typed virtual machine, the class file format may encode most type information as string literals. This is a convenient choice because some virtual machines, such as the Java virtual machine (JVM), implement a nominal type-system, where each class is identified by a name. However, string-literal encoding may be problematic when trying to represent richer type information, particularly for structural types such as tuple types, function types, or parameterized class types.
A generic class is a template from which different actual parameterized types may be instantiated by specifying particular combinations of type arguments. For example, a Java List type is a generic class that may be instantiated as a List of Strings, List of Numbers, and so forth. The following terminology may be used herein.                class List<X> { . . . } is a generic class declaration        X in ‘class List<X>’ is a type-variable or type parameter        List<String> is a parameterized type as obtained by instantiating a generic class        String in List<String> is a type-argument        
These terms support the following additional semantics.                one generic class can be instantiated into many parameterized types        a parameterized type binds the type-variable array into a concrete type-arguments array        
Directly supporting constructs such as parameterized types in some virtual machines may generally be difficult and require that the virtual machine be aware of several language-level properties such as subtyping, type-substitution, and variance. Moreover, such properties may differ between different programming source languages.
Other virtual machines, such as the .NET VM, have properties that are often quite different from virtual machines that were initially developed to support statically typed languages, such as the JVM. For example, the .NET VM has mechanisms for handling parameterized types embedded directly within it. Primitive type arguments for generic types is another example of a feature often not implemented by virtual machines that support statically-typed languages. Furthermore, providing support for such new language features within existing virtual machines risks breaking migration compatibility by disrupting the design of the virtual machine execution environment. For example, implementing improvements to parameterized types in the Java language risks breaking backwards compatibility migration of legacy JVM systems by disrupting the design of the JVM execution environment.